// packageA/pages/attendancePlanNew/attendancePlanNew.js
import CommonService from '../../../utils/service/commonService.js';
import Toast from '../../../miniprogram_npm/@vant/weapp/toast/toast';
import { relativeTimeThreshold } from '../../../libs/moment.min.js';
const util = require('../../../utils/util');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    //传参
    paramObj:null,
    //区域列表
    areaList: [],
    //班次列表
    timeList: [],
    //人员排班列表
    nameList: [],
    //人员选择框
    showUser: false,
    //人员列表
    list: [],
    //无人员数据
    showNothing: false,
    //人员搜索关键词
    searchValue: '',
    //已选人员列表
    listMap: {},
    //全选
    checkedAll: false,
    //当前点击的格子
    currentBox: {},
    //日期选择框
    showDate:false,
    currentDate: new Date().getTime(),
    currentDateStr: util.timeFormatDay(new Date()),
    formatter(type, value) {
      if (type === 'year') {
        return `${value}年`;
      } else if (type === 'month') {
        return `${value}月`;
      }
      return value;
    },
    //考勤组信息
    groupInfo: null,
    //是否显示提交按钮（今天之前的不能再修改）
    showBtn: true,
    //排班id
    planId: null,
    //显示未排班
    showNoPlan: false,
    //排班日期单选
    radio: '1',
    //日历范围
    dateRange: [new Date().getTime(), (util.countNextDay(new Date(),30)).getTime()],
    //显示日历
    showCalendar: false,
    //最小值为今天
    minDate: new Date().getTime(),
    //最大值为7天后
    maxDate: (util.countNextDay(new Date(),30)).getTime(),
    //开始日期
    startTime: '',
    //结束日期
    endTime: '',
    //是否显示单选框
    showRadio: false,
    selectedPersonnel: {} // 格式: { imei: cellId }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.setData({
      //在这里给map赋值，避免后面操作时set方法不可用
      listMap: new Map()
    })

    if(options.paramObj){
      let paramObj=JSON.parse(options.paramObj);
      console.log('排班传参');
      console.log(paramObj);

      this.setData({
        paramObj: paramObj
      })

      Toast.loading({
        duration: 0,
        forbidClick: true,
        message: '加载中...'
      });

      //获取人员列表
      this.getUserList();

      setTimeout(() => {
        //获取考勤组数据
        this.getGroupData();
      }, 1000);
    }
  },

  //获取考勤组数据
  getGroupData(){
    let param = {
      isAuth: false,
      className: 'attendanceGroup',
      data: {
        id: this.data.paramObj.attendanceGroupId,
        selectFields: ['id','name','attendanceShifts','fences','workArea','dataAuthority','depart']
      }
    }

    CommonService.goFindList(param).then(res => {
      if(res.data.data && res.data.data.result && res.data.data.result.length) {
        let result=res.data.data.result[0];
        console.log('考勤组信息');
        console.log(result);

        this.setData({
          //考勤组信息
          groupInfo: result,
          //区域
          areaList: result.workArea,
          //班次
          timeList: result.attendanceShifts
        })

        //获取排班数据
        this.getPlanData();
      }
    }).catch((error) => {
    })
  },

  //获取排班数据
  getPlanData(){
    //未排班先隐藏
    this.setData({
      showNoPlan: false
    })

    let param = {
      isAuth: false,
      className: 'employeeSchedulingArea',
      data: {
        attendanceGroupId: this.data.paramObj.attendanceGroupId,
        // dt: {
        //   '>=': this.data.currentDateStr+' 00:00:00',
        //   '<=': this.data.currentDateStr+' 23:59:59'
        // },
        selectFields: ['id','dt','attendanceGroupId','attendanceGroupName','shiftSchedulingData'],
        sort: {dt: -1},
      }
    }

    CommonService.goFindList(param).then(res => {
      let planData=[];
      let planId=null;

      if(res.data.data && res.data.data.result && res.data.data.result.length) {
        let result=res.data.data.result[0];
        console.log('已排班数据');
        console.log(result);
      
        //排班id
        planId=result.id;

        //排班数据
        if(result.shiftSchedulingData && result.shiftSchedulingData.length){
          planData=result.shiftSchedulingData;
        }
      }

      this.setData({
        planId: planId
      })

      //无排班并且是今天，才显示单选框
      if(!planId && this.data.showBtn){
        this.setData({
          showRadio: true
        })
      }else{
        this.setData({
          showRadio: false
        })
      }

      //处理排班数据
      this.handlePlanData(planData);

    }).catch((error) => {
    })
  },

  //处理排班数据
  handlePlanData(planData){
    console.log("planData");
    console.log(planData);
    //是否是今天
    let showBtn=true;
    //区域
    let areaList=[...this.data.areaList];
    //班次
    let timeList=[...this.data.timeList];
    console.log("----------------------------");

    //所有人员
    let personList=[...this.data.list];
    //排班人员
    let nameList=[];

    //初始化人员
    timeList.forEach(item => {
      item.personnel=[];
    });

    if(!planData.length){
      if(showBtn){
        console.log("4444444444444444444444444444")
        //未排过班的，初始化数据
        areaList.forEach(item => {
          nameList.push({
            id: item.id,
            name: item.name,
            shift: timeList
          });
        });
      }else{
        console.log("333333333333333333333333333")
        //今天之前如果没数据，显示未排班
        this.setData({
          showNoPlan: true
        })
      } 
    }else{
      if(showBtn){
        console.log("11111111111111111111111111111")
        /*
          已排过班的，今天之后的需要处理数据，按照考勤组的区域、班次、人员合并，有的覆盖，没有的去掉
        */
        //组中区域放入map
        let map=new Map();
        areaList.forEach(item => {
          //初始化班次和人员字段
          item.shift=timeList;
          map.set(item.id,item);
        });
        //组中班次放入map
        let mapTime=new Map();
        timeList.forEach(item => {
          mapTime.set(item.id,item);
        });
        //所有人员放入map
        let mapP=new Map();
        personList.forEach(item => {
          mapP.set(item.imei,item);
        });
        //已排过的，把组中数据筛出来
        let arr=[];
        planData.forEach(item => {
          if(map.has(item.id)){
            //处理班次
            let shift=[...item.shift];
            let timeArr=[];
            shift.forEach(item2 => {
              if(mapTime.has(item2.id)){
                //去掉不在组中的人员
                let personnel = []
                if (item2.personnel != null){
                  personnel=[...item2.personnel];
                }
            
                let newP=[];
                personnel.forEach(item4 => {
                  if(mapP.has(item4.imei)){
                    newP.push(item4);
                  }
                });
                //item2.personnel=newP;
                //人员数量self_num用于计算格子高度
                item2.self_num=newP.length;

                //班次名字和时间改成组中的
                item2.ruleName=mapTime.get(item2.id).ruleName;
                item2.ruleTime=mapTime.get(item2.id).ruleTime;
                //班次数据放入新数组
                timeArr.push(item2);
              }
            });
            //覆盖组中的班次
            timeArr.forEach(item3 => {
              mapTime.set(item3.id,item3);
            });
            //班次map转成数组
            item.shift=[...mapTime.values()];

            //区域名字改成组中设置的名字
            item.name=map.get(item.id).name;
            //区域数据放入新数组
            arr.push(item);
          }
        });
        console.log("33333333333333333333333333333333")
        //覆盖组中的区域
        arr.forEach(item => {
          map.set(item.id,item);
        });

        //区域map转成数组
        nameList=[...map.values()];
      }else{
        console.log("2222222222222222222222222222222")
        //今天之前的直接显示即可
        nameList=planData;  
      }
      console.log("2222222222222222222222222222222")
      //今天之前的直接显示即可
      nameList=planData;  
    }

    //超过当前时间的不能排班
    let currentTime=new Date();
    let currentDateStr=this.data.currentDateStr;
    nameList.forEach(item => {
      let shift=[...item.shift];
      
      //self_num用于计算格子高度
      let max=0;
      if(shift[0].self_num!=null){
        max=shift[0].self_num;
      }

      shift.forEach(item2 => {
        if(this.data.showBtn){
          let timeStr=currentDateStr+' '+item2.ruleTime[0].clockInTime+':00';
          //转换成/兼容ios
          timeStr=timeStr.replaceAll('-','/');
          let times=new Date(timeStr);
          
          if(times<=currentTime){
            item2.self_not=false;
          }else{
            item2.self_not=false;
          }
        }else{
          item2.self_not=false;
        }
        console.log("qaaaaaaaaaaaaaaaa");
        let personnelLength = 0;
        if (item2.personnel != null){
          personnelLength = item2.personnel.length
        }
        item2.self_num=personnelLength;
        console.log("qaaaaaaaaaaaaaaaa111111111111111111");
        //格子高度为人员最多的数量
        if(item2.self_num>max){
          max=item2.self_num;
        }
      });

      item.self_max=max;
      item.shift=shift;
    });

    console.log('处理后排班列表');
    console.log(nameList);    

    this.setData({
      nameList: nameList
    }) 

    Toast.clear();
  },

  //点击格子显示人员选择框
  onClickName({currentTarget}){
    let dataset=currentTarget.dataset;
    //当前时间之后的才能排
   // if(this.data.showBtn && !dataset.time.self_not){
       // 生成当前单元格的唯一标识
       const cellId = `${dataset.time.id}`;
      this.setData({
        showUser: true,
        currentBox: dataset,
        currentCellId: cellId
      })
      console.log("dataset");
      console.log(dataset);
      //选中人员回显（人员放入map）
      if(dataset.personnel!=null&&dataset.personnel.length){
        let listMap=new Map();
        let list=this.data.list;
        dataset.personnel.forEach(item => {
          listMap.set(item.imei,item);
        });

        list.forEach(item => {
          if(listMap.get(item.imei)){
            item.checked=true;
          }
        });
        this.data.selectedPersonnel={}
        //获取所有单元格已经选中的人员
        dataset.area.shift.forEach(item =>{
          item.personnel.forEach(item1 => {
            console.log(item1,"---");
            this.data.selectedPersonnel[item1.imei] = item.id+""
          })
        })
        this.setData({
          listMap: listMap,
          list: list,
          selectedPersonnel:this.data.selectedPersonnel
        })
        // 重新过滤列表
        this.filterList();
      }else{
        this.data.selectedPersonnel={}
           //获取所有单元格已经选中的人员
        dataset.area.shift.forEach(item =>{
          if (item.personnel!=null){
            item.personnel.forEach(item1 => {
              console.log("00000");
              this.data.selectedPersonnel[item1.imei] = item.id+""
            })
          }
          
        })
        this.setData({
          selectedPersonnel:this.data.selectedPersonnel
        })
        // 重新过滤列表
        this.filterList();
      }
   // }
  },

  // 过滤掉已被其他单元格选中的人员
  filterList() {
    const { list, currentCellId } = this.data;
    this.setData({
      list: list.map(item => ({
        ...item,
        checked:this.isSelectedImei(item.imei),
        disabled: this.isSelectedByOtherCell(item.imei)
      }))
    });
    console.log(this.data.list);
  },
// 检查人员是否被其他单元格选中
isSelectedImei(imei) {
  
  const { selectedPersonnel, currentCellId } = this.data;
  return selectedPersonnel[imei];
},
  // 检查人员是否被其他单元格选中
  isSelectedByOtherCell(imei) {
    const { selectedPersonnel, currentCellId } = this.data;
    console.log(selectedPersonnel);
    return selectedPersonnel[imei] && selectedPersonnel[imei] !== currentCellId;
  },

  //确定人员
  onConfirmUser(){
    let nameList=this.data.nameList;
    let currentBox=this.data.currentBox;
    let listMap=this.data.listMap;

    //选择的人员
    let selectlist=[];
    listMap.forEach(item => {
      selectlist.push({
        id: item.id,
        name: item.nickName ? item.nickName : item.name,
        nickName: item.nickName ? item.nickName : item.name,
        imei: item.imei,
        devId: item.devId,
        hitId: item.hitId
      });
    });

    //点击时匹配区域和班次，把人员加进去
    nameList.forEach(item => {
		  if(item.id==currentBox.area.id){
        //需要深拷贝，不然会选上所有区域格子
        let time=JSON.parse(JSON.stringify(item.shift));
        time.forEach(item2 => {
          if(item2.id==currentBox.time.id){
            item2.personnel=selectlist;
            item2.self_num=selectlist.length;
          }
        });
        //赋值
        item.shift=time;
      }
    });

    //处理区域高度
    this.areaHeight();
  },

  //清除当前格子的人员
  onEmpty(){
    let nameList=this.data.nameList;
    let currentBox=this.data.currentBox;

    nameList.forEach(item => {
		  if(item.id==currentBox.area.id){
        let time=JSON.parse(JSON.stringify(item.shift));
        time.forEach(item2 => {
          if(item2.id==currentBox.time.id){
            item2.personnel=[];
            item2.self_num=0;
          }
        });
        item.shift=time;
      }
    });

    //处理区域高度
    this.areaHeight();
  },

  //处理区域高度
  areaHeight(){
    let nameList=this.data.nameList;
    let currentBox=this.data.currentBox;

    nameList.forEach(item => {
		  if(item.id==currentBox.area.id){
        let time=JSON.parse(JSON.stringify(item.shift));
        //找到班次中名字最多的格子
        let max=0;
        if(time[0].self_num!=null){
          max=time[0].self_num;
        }
        time.forEach(item3 => {
          if(item3.self_num>max){
            max=item3.self_num;
          }
        });
        item.self_max=max;
        item.shift=time;
      }
    });

    this.setData({
      nameList: nameList
    })

    //隐藏选择人员
    this.onCloseUser();
  },

  //隐藏选择人员
  onCloseUser(){
    this.setData({
      showUser: false,
      searchValue: '',
      listMap: new Map(),
      disabled: false
    })
    this.refreshListAndPage();
  },

  //获取人员列表
  getUserList(){
    let param={
      //只查这个部门的人员
      depart: [this.data.paramObj.attendanceDepartId]
    };

    //模糊查询
    if(this.data.searchValue){
      param.keyword = this.data.searchValue;
    }

    CommonService.findPersonnelAll(param).then(res => {
      if(res.data.data && res.data.data.result && res.data.data.result.length) {
        let result=res.data.data.result;  
        //选中状态
        let listMap=this.data.listMap;
        result.forEach(item => {
          if(listMap.get(item.imei)){
            item.checked=true;
          }
          //无hitId的不能选择
          if(!item.hitId){
            item.disabled=true;
          }
        });

        this.setData({
          list: result
        })

        console.log('人员选项');
        console.log(result);

      }else{
        this.setData({
          showNothing: true
        })
      }
    }).catch((error) => {
      this.setData({
        showNothing: true
      })
    })
  },

  //刷新列表
  refreshListAndPage(){
    this.setData({
      list: [],
      showNothing: false,
      checkedAll: false
    })
    this.getUserList();
  },

  //获取搜索词
  onChangeSearch(e) {
    this.setData({
      searchValue: e.detail
    })
    this.refreshListAndPage();
  },

  //选择列表
  onChangeCheck({currentTarget}) {
    let detail=currentTarget.dataset.detail;
    let list=this.data.list;
    let listMap=this.data.listMap;

    list.forEach(item => {
		  if(item.imei==detail.imei){
        //点击复选框时切换选中
        item.checked=!item.checked;
        if(item.checked){
          //选中的放入已选列表，利用map避免重复
          listMap.set(item.imei,item);
        }else{
          //未选中的从map中删除
          listMap.delete(item.imei);
        }
      }
    });

    //列表是否全被选中了
    let flag=list.every(item=>{
      return item.checked || item.disabled;
    });

    //是否选中全选
    if(flag){
      this.setData({
        checkedAll: true
      })
    }else{
      this.setData({
        checkedAll: false
      })
    }

    this.setData({
      list: list,
      listMap: listMap
    })
  },

  //全选
  onChangeAll(event){
    let list=this.data.list;
    let listMap=this.data.listMap;

    list.forEach(item => {
      if(!item.disabled){
        //列表的复选框与全选的值一致
        item.checked=event.detail;
        if(event.detail){
          //选中的放入已选列表
          listMap.set(item.imei,item);
        }else{
          //未选中的从map中删除
          listMap.delete(item.imei);
        }
      }
    });

    this.setData({
      checkedAll: event.detail,
      list: list,
      listMap: listMap
    })
  },

  //显示日期选择框
  onShowDate(){
    this.setData({
			showDate: true
		})
  },

  //关闭日期选择框
  onCloseDate(){
    this.setData({
			showDate: false
		})
  },

  //确定日期
  onConfirmDate(event){
    let currentDate=event.detail;
    let today=util.timeFormatDay(new Date());
    let currentDateStr=util.timeFormatDay(currentDate);

    this.setData({
      currentDate: currentDate,
      currentDateStr: currentDateStr,
      //日历范围
      dateRange: [currentDate, (util.countNextDay(new Date(currentDate),30)).getTime()],
      //日历最小值
      minDate: currentDate,
      //日历最大值
      maxDate: (util.countNextDay(new Date(currentDate),30)).getTime(),
      //排班日期单选
      radio: '1',
      //开始日期
      startTime: '',
      //结束日期
      endTime: ''
    })

    //今天之前的不能修改，隐藏提交按钮
    if(currentDateStr<today){
      this.setData({
        showBtn: false
      })
    }else{
      this.setData({
        showBtn: true
      })
    }

    //获取排班数据
    this.getPlanData();

    //关闭日期选择框
    this.onCloseDate();
  },

  //保存排班##
  onConfirmPlan(){
    //避免表单重复提交-先禁用按钮
    this.setData({
      disabled: true
    })

    let td=this.data;
    let groupInfo=td.groupInfo;
    let nameList=td.nameList;

    /*
      未排班人员
    */
    let map=new Map();
    let list=td.list;

    //先把排的放一个map中
    nameList.forEach(item => {
      item.shift.forEach(item2 => {
        let person=item2.personnel;
        for(let i=0;i<person.length;i++){
          map.set(person[i].imei,person[i]);
        }
      });
    });

    //排过的与整个人员列表比较
    let notArr=[];
    list.forEach(item => {
      if(!map.get(item.imei)){
        notArr.push({
          imei: item.imei,
          nickName: item.nickName,
          hitId: item.hitId
        });
      }
    });

    //处理日期
    let dt=[];
    if(td.planId){
      //只能修改当天，dt传今天就行
      dt.push(td.currentDateStr);
    }else{
      if(td.radio=='1'){
        //单选选了只排当天
        dt.push(td.currentDateStr);
      }else if(td.radio=='2'){
        //添加时，单选选了范围，dt传选择的日期列表
        let startTime=td.startTime;
        let endTime=td.endTime;

        if(startTime && endTime){
          //把选择的日期范围列出来
          dt=this.getDateStr(startTime, endTime, 0);

        }else{
          Toast.fail('请选择排班日期范围');
          return;
        }
      }
    }

    let param={
      id: td.planId,
      //日期
      dt: dt,
      //考勤组id
      attendanceGroupId: groupInfo.id,
      //考勤组名称
      attendanceGroupName: groupInfo.name,
      //围栏
      fence: groupInfo.fences,
      //权限
      dataAuthority: groupInfo.dataAuthority,
      //排班
      shiftSchedulingData: nameList,
      //未排过班的人员
      outPersonnel: notArr,
      //项目
      departId: groupInfo.depart.id,
      departName: groupInfo.depart.name
    }

    // console.log(param);
    // return;

    //避免表单重复提交
    Toast.loading({
      duration: 0,
      forbidClick: true,
      message: '数据提交中...'
    });

    CommonService.saveRostering(param).then(res=>{
      this.setData({
        disabled:false
      })
      if (res.statusCode == 200 && res.data.success == true){
        Toast.success('成功');
        setTimeout(() => {
          //返回列表页并刷新数据
          this.backAndRefresh();
        }, 1000);
      }else if(res.statusCode==202){
        Toast.fail('您操作太快了,请勿重复提交');
      }else{
        Toast.fail('操作失败');
      }
    }).catch((error) => {
      Toast.fail('操作失败');
    })
  },

  //返回列表页并刷新数据
  backAndRefresh(){
    let pages = getCurrentPages();
    let prevPage = pages[pages.length - 2];

    prevPage.refreshListAndPage();
    wx.navigateBack();
  },

  //排班日期单选
  onChangeRadio(event) {
    this.setData({
      radio: event.detail,
      disabled: false
    })
  },

  //显示日历
  onShowCalendar() {
    this.setData({
      showCalendar: true
    })
  },

  //隐藏日历
  onCloseCalendar() {
    this.setData({
      showCalendar: false
    })
  },

  //确认日期
  onConfirmCalendar(event) {
    const [start,end] = event.detail;
    this.setData({
      showCalendar: false,
      startTime: util.timeFormatDay(start),
      endTime: util.timeFormatDay(end),
      disabled: false
    })
  },

  //startDate: 计划开始时间； endDate：计划结束时间；dayLength：每隔几天，0-代表每天，1-代表日期间隔一天，返回日期范围数组
  getDateStr(startDate, endDate, dayLength){
    let arr = [startDate];
    for (let i = 0 ;; i++) {
      let getDate = this.getTargetDate(startDate, dayLength);
      startDate = getDate;
      if (getDate <= endDate) {
        arr.push(getDate);
      } else {
        break;
      }
    }
    return arr;
  },

  //计算后一天的日期，返回年-月-日
  getTargetDate(date,dayLength) {
    dayLength = dayLength + 1;
    let tempDate = new Date(date);
    tempDate.setDate(tempDate.getDate() + dayLength);
    let year = tempDate.getFullYear();
    let month = tempDate.getMonth() + 1 < 10 ? "0" + (tempDate.getMonth() + 1) : tempDate.getMonth() + 1;
    let day = tempDate.getDate() < 10 ? "0" + tempDate.getDate() : tempDate.getDate();
    return year + "-" + month + "-" + day;
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  }
})
